home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / misc / gnuplot-3.7src.lha / gnuplot-3.7src / gnuplot-3.7.lha / gnuplot-3.7 / term / gpr.trm < prev    next >
Text File  |  1998-12-14  |  14KB  |  474 lines
  1. /*
  2.  * $Id: gpr.trm,v 1.13 1998/04/14 00:17:46 drd Exp $
  3.  *
  4.  */
  5.  
  6. /* GNUPLOT - gpr.trm */
  7.  
  8. /*[
  9.  * Copyright 1990 - 1993, 1998
  10.  *
  11.  * Permission to use, copy, and distribute this software and its
  12.  * documentation for any purpose with or without fee is hereby granted,
  13.  * provided that the above copyright notice appear in all copies and
  14.  * that both that copyright notice and this permission notice appear
  15.  * in supporting documentation.
  16.  *
  17.  * Permission to modify the software is granted, but not the right to
  18.  * distribute the complete modified source code.  Modifications are to
  19.  * be distributed as patches to the released version.  Permission to
  20.  * distribute binaries produced by compiling modified sources is granted,
  21.  * provided you
  22.  *   1. distribute the corresponding source modifications from the
  23.  *    released version in the form of a patch file along with the binaries,
  24.  *   2. add special version identification to distinguish your version
  25.  *    in addition to the base release version number,
  26.  *   3. provide your name and address as the primary contact for the
  27.  *    support of your modified version, and
  28.  *   4. retain our contact information in regard to use of the base
  29.  *    software.
  30.  * Permission to distribute the released version of the source code along
  31.  * with corresponding source modifications in the form of a patch file is
  32.  * granted with same provisions 2 through 4 for binary distributions.
  33.  *
  34.  * This software is provided "as is" without express or implied warranty
  35.  * to the extent permitted by applicable law.
  36. ]*/
  37.  
  38. /*
  39.  * This file is included by ../term.c.
  40.  *
  41.  * This terminal driver supports:
  42.  *   APOLLO's GPR windowing system
  43.  *
  44.  * AUTHORS
  45.  *  Michael Aramini
  46.  *  Roque D Oliveira , oliveria@caen.engin.umich.edu
  47.  * 
  48.  * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
  49.  * 
  50.  */
  51.  
  52. /*
  53.  * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
  54.  */
  55.  
  56. #include "driver.h"
  57.  
  58. #ifdef TERM_REGISTER
  59. register_term(gpr)
  60. #endif
  61.  
  62. #ifdef TERM_PROTO
  63. TERM_PUBLIC void GPR_init __PROTO((void));
  64. TERM_PUBLIC void GPR_graphics __PROTO((void));
  65. TERM_PUBLIC void GPR_text __PROTO((void));
  66. TERM_PUBLIC void GPR_linetype __PROTO((int linetype));
  67. TERM_PUBLIC void GPR_move __PROTO((unsigned int x, unsigned int y));
  68. TERM_PUBLIC void GPR_vector __PROTO((unsigned int x, unsigned int y));
  69. TERM_PUBLIC void GPR_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  70. TERM_PUBLIC int GPR_text_angle __PROTO((int ang));
  71. TERM_PUBLIC int GPR_justify_text __PROTO((enum JUSTIFY mode));
  72. TERM_PUBLIC void GPR_reset __PROTO((void));
  73. /* landscape window */
  74. /*
  75. #define GPR_XMAX 720
  76. #define GPR_YMAX 450
  77. */
  78. /* portrait window */
  79. #define GPR_XMAX 585
  80. #define GPR_YMAX 735
  81. #define GPR_VCHAR 19
  82. #define GPR_HCHAR 10
  83. #define GPR_VTIC (GPR_YMAX/80)
  84. #define GPR_HTIC (GPR_XMAX/80)
  85. #endif /* TERM_PROTO */
  86.  
  87. #ifndef TERM_PROTO_ONLY
  88. #ifdef TERM_BODY
  89. void GPRold_linetype __PROTO((int linetype));
  90. static void check __PROTO((char *messagex));
  91. int gpr_isa_pad __PROTO((void));
  92. #include <apollo/base.h>
  93. #include <apollo/error.h>
  94. #include <apollo/gpr.h>
  95. #include <apollo/pad.h>
  96.  
  97. #define GPR_XLAST (GPR_XMAX - 1)
  98. #define GPR_YLAST (GPR_YMAX - 1)
  99.  
  100.  
  101. gpr_$direction_t gpr_path = gpr_$right;
  102. /* text angle, 0=horizontal, 1=vertical */
  103. int gpr_ang = 0;
  104. /* text is flush left */
  105. enum JUSTIFY gpr_justify = LEFT;
  106.  
  107. static status_$t status;
  108. /* set it to 1 when debugging program */
  109. unsigned int Debug = 0;
  110.  
  111.  
  112. static void check(messagex)
  113. char *messagex;
  114. {
  115.     if (status.all = status_$ok) {
  116.     error_$print(status);
  117.     printf("Error occurred while %s.\n", messagex);
  118.     }
  119. }
  120.  
  121. /* return whether stdout is a DM pad . Called by term.c */
  122. int gpr_isa_pad()
  123. {
  124.     pad_$isa(1, &status);
  125.     return (status.all == status_$ok);
  126. }
  127.  
  128.  
  129. TERM_PUBLIC void GPR_init()
  130. {
  131.     gpr_$offset_t dm_bitmap_size;
  132.     gpr_$bitmap_desc_t dm_bitmap_desc;
  133.     pad_$window_desc_t window;
  134.     short font_id;
  135.     stream_$id_t stream_id;
  136.     static gpr_$rgb_plane_t hi_plane;
  137.     static gpr_$disp_char_t display_characteristics;
  138.     static float screen_size_r_width, screen_size_r_height;
  139.     static short int disp_len = sizeof(gpr_$disp_char_t);
  140.     static short int disp_len_returned;
  141.  
  142.  
  143.     /* open a pad to do graphics in */
  144.     window.top = 0;
  145.     window.left = 0;
  146.     /* 10 accounts for width of window border */
  147.     window.width = GPR_XMAX + 10;
  148.     /* 35 accounts for height of window border */
  149.     window.height = GPR_YMAX + 35;
  150.     pad_$create_window("", (short) 0, pad_$transcript, (short) 1, window, &stream_id, &status);
  151.     check("pad_$create_window");
  152.  
  153. /*  pad_$set_full_window(stream_id,(short) 1,&window, &status); */
  154. /*  pad_$set_border (stream_id,(short) 1, true, &status); */
  155.     pad_$set_scale(stream_id, (short) 1, (short) 1, &status);
  156.     pad_$set_auto_close(stream_id, (short) 1, true, &status);
  157.  
  158.     gpr_$inq_disp_characteristics(gpr_$direct, stream_id, disp_len, &display_characteristics, &disp_len_returned, &status);
  159.     check("in gpr_$inq_display_characteristics");
  160.     /*x_window_size in pixels */
  161.     screen_size_r_width = (float) display_characteristics.x_window_size;
  162.     /*y_window_size in pixels */
  163.     screen_size_r_height = (float) display_characteristics.y_window_size;
  164.     hi_plane = display_characteristics.n_planes - 1;
  165.     if (Debug)
  166.     printf("width=%f height=%f \n", screen_size_r_width, screen_size_r_height);
  167.  
  168.     dm_bitmap_size.x_size = 1280;
  169.     dm_bitmap_size.y_size = 1024;
  170.     gpr_$init(gpr_$direct, stream_id, dm_bitmap_size, hi_plane, &dm_bitmap_desc, &status);
  171.     check("in gpr_$init");
  172. /*
  173.   gpr_$set_obscured_opt(gpr_$pop_if_obs, &status); 
  174.   check("in gpr_$set_obscured_opt");
  175. */
  176.     gpr_$set_auto_refresh(true, &status);
  177.     check("in gpr_$set_auto_refresh");
  178.  
  179.     /* load a font and make it current */
  180.     gpr_$load_font_file("f7x13", 5, &font_id, &status);
  181.     check("in gpr_$load_font_file");
  182.     gpr_$set_text_font(font_id, &status);
  183.     check("in gpr_$set_text_font");
  184.  
  185.     /* set up color values */
  186.     gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status);    /* white */
  187.     check("in gpr_set_draw_value");
  188.     gpr_$set_text_background_value((gpr_$pixel_value_t) (-1), &status);    /* trans */
  189.     check("in gpr_$set_text_background_value");
  190.     gpr_$set_text_value((gpr_$pixel_value_t) 7, &status);    /* white */
  191.     check("in gpr_$set_text_value");
  192. }
  193.  
  194.  
  195. TERM_PUBLIC void GPR_graphics()
  196. {
  197.     gpr_$coordinate_t locx, locy, marker_size;
  198.  
  199.     (void) gpr_$acquire_display(&status);
  200.     check("in gpr_$acquire display");
  201.     gpr_$clear((gpr_$pixel_value_t) 0, &status);    /* black */
  202.     check("in gpr_$clear");
  203.  
  204.     if (Debug) {
  205.     marker_size = (short) 10;
  206.  
  207.     locx = (short) 5;
  208.     locy = (short) 5;
  209.     gpr_$set_draw_value((gpr_$pixel_value_t) 2, &status);    /* white */
  210.     gpr_$move((locx - marker_size / 2), locy, &status);
  211.     gpr_$line((locx + marker_size / 2), locy, &status);
  212.     gpr_$move(locx, (locy + marker_size / 2), &status);
  213.     gpr_$line(locx, (locy - marker_size / 2), &status);
  214.  
  215.     locx = (short) (GPR_XMAX - 1 - 5);
  216.     locy = (short) 5;
  217.     gpr_$set_draw_value((gpr_$pixel_value_t) 3, &status);    /* white */
  218.     gpr_$move((locx - marker_size / 2), locy, &status);
  219.     gpr_$line((locx + marker_size / 2), locy, &status);
  220.     gpr_$move(locx, (locy + marker_size / 2), &status);
  221.     gpr_$line(locx, (locy - marker_size / 2), &status);
  222.  
  223.     locx = (short) 5;
  224.     locy = (short) (GPR_YMAX - 1 - 5);
  225.     gpr_$set_draw_value((gpr_$pixel_value_t) 4, &status);    /* white */
  226.     gpr_$move((locx - marker_size / 2), locy, &status);
  227.     gpr_$line((locx + marker_size / 2), locy, &status);
  228.     gpr_$move(locx, (locy + marker_size / 2), &status);
  229.     gpr_$line(locx, (locy - marker_size / 2), &status);
  230.  
  231.     locx = (short) (GPR_XMAX - 1 - 5);
  232.     locy = (short) (GPR_YMAX - 1 - 5);
  233.     gpr_$set_draw_value((gpr_$pixel_value_t) 5, &status);    /* white */
  234.     gpr_$move((locx - marker_size / 2), locy, &status);
  235.     gpr_$line((locx + marker_size / 2), locy, &status);
  236.     gpr_$move(locx, (locy + marker_size / 2), &status);
  237.     gpr_$line(locx, (locy - marker_size / 2), &status);
  238.  
  239.     gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status);    /* white */
  240.     check("in gpr_$set_draw_value");
  241.     }                /* end if(Debug) */
  242. }
  243.  
  244.  
  245. TERM_PUBLIC void GPR_text()
  246. {
  247.     gpr_$release_display(&status);
  248.     check("gpr_$release_display");
  249. }
  250.  
  251.  
  252. void GPRold_linetype(linetype)
  253. int linetype;
  254. {
  255.     static gpr_$line_pattern_t patterns[2 + 5] =
  256.     {
  257.     {0xFFFF},        /* solid              1111111111111111 */
  258.     {0x3FFF},        /* very long dashed   0011111111111111 */
  259.     {0xFFFF},        /* solid              1111111111111111 */
  260.     {0x5555},        /* dotted             0101010101010101 */
  261.     {0x3333},        /* short dashed       0011001100110011 */
  262.     {0xB5AD},        /* dot short-dashed   1011010110101101 */
  263.     {0x3FFF}        /* very long dashed   0011111111111111 */
  264.     };
  265.     if (linetype >= 5)
  266.     linetype %= 5;
  267.     gpr_$set_line_pattern((short) 1, patterns[linetype + 2], (short) 16, &status);
  268.     check("in gpr_$set_line_pattern");
  269. }
  270.  
  271. TERM_PUBLIC void GPR_linetype(linetype)
  272. int linetype;
  273. {
  274.     static gpr_$line_pattern_t patterns[2 + 7] =
  275.     {
  276.     {0xFFFF},        /* solid              1111111111111111 */
  277.     {0x1111},        /* long-spaced dotted 0001000100010001 */
  278.     {0xFFFF},        /* solid              1111111111111111 */
  279.     {0x5555},        /* dotted             0101010101010101 */
  280.     {0x3333},        /* short  dashed      0011001100110011 */
  281.     {0x7777},        /* medium dashed      0111011101110111 */
  282.     {0x3F3F},        /* long   dashed      0011111100111111 */
  283.     {0x0F0F},        /* long-spaced dashed 0000111100001111 */
  284.     {0x5F5F}        /* dot dashed         0101111101011111 */
  285.     };
  286.     if (linetype >= 7)
  287.     linetype %= 7;
  288.     gpr_$set_line_pattern((short) 1, patterns[linetype + 2], (short) 16, &status);
  289.     check("in gpr_$set_line_pattern");
  290.  
  291. /*
  292.   gpr_$set_draw_value((gpr_$pixel_value_t)(linetype + 1), &status);
  293.   check("in gpr_$set_draw_value");
  294. */
  295. }
  296.  
  297.  
  298. TERM_PUBLIC void GPR_move(x, y)
  299. unsigned int x, y;
  300. {
  301.     gpr_$move((short) x, (short) (GPR_YMAX - 1 - y), &status);
  302.     check("in gpr_$move");
  303. }
  304.  
  305.  
  306. TERM_PUBLIC void GPR_vector(x, y)
  307. unsigned int x, y;
  308. {
  309.     gpr_$line((short) x, (short) (GPR_YMAX - 1 - y), &status);
  310.     check("in gpr_$line");
  311. }
  312.  
  313.  
  314. TERM_PUBLIC void GPR_put_text(x, y, str)
  315. unsigned int x, y;        /* reference point of string */
  316. char str[];            /* the text */
  317. {
  318.     gpr_$coordinate_t xgpr, ygpr;
  319.     gpr_$offset_t str_size_in_pixels;
  320.     short int str_len;
  321.  
  322.     gpr_$coordinate_t locx, locy, marker_size;
  323.  
  324.     if (Debug) {
  325.     locx = (short) x;
  326.     locy = (short) (GPR_YMAX - 1 - y);
  327.     marker_size = (short) 20;
  328.     gpr_$set_draw_value((gpr_$pixel_value_t) 1, &status);    /* white */
  329.     gpr_$move((locx - marker_size / 2), locy, &status);
  330.     gpr_$line((locx + marker_size / 2), locy, &status);
  331.     gpr_$move(locx, (locy + marker_size / 2), &status);
  332.     gpr_$line(locx, (locy - marker_size / 2), &status);
  333.     gpr_$set_draw_value((gpr_$pixel_value_t) 7, &status);    /* white */
  334.     }
  335.     xgpr = (short) x;
  336.     ygpr = (short) (GPR_YMAX - 1 - y);
  337.     gpr_$set_text_path(gpr_path, &status);
  338.     check("gpr_$set_text_path");
  339.  
  340.     str_len = (short) strlen(str);
  341.     /* Calculate how much space (in pixels) the string requires */
  342.     gpr_$inq_text_extent(str, str_len, &str_size_in_pixels, &status);
  343.     check("in gpr_$inq_text_extent");
  344.  
  345.     switch (gpr_justify) {
  346.     case LEFT:
  347.     {
  348.         switch (gpr_path) {
  349.         case gpr_$up:    /* vertical */
  350.         {
  351.             if (Debug)
  352.             printf("LEFT and up , str=%s\n", str);
  353.             break;
  354.         }
  355.         case gpr_$right:    /* horizontal */
  356.         {
  357.             ygpr = ygpr + str_size_in_pixels.y_size / 2;
  358.             if (Debug)
  359.             printf("LEFT and right, str=%s \n", str);
  360.             break;
  361.         }
  362.         }
  363.         break;
  364.     }
  365.  
  366.     case CENTRE:
  367.     {
  368.         switch (gpr_path) {
  369.         case gpr_$up:    /* vertical */
  370.         {
  371.             xgpr = xgpr + str_size_in_pixels.x_size / 2;
  372.             ygpr = ygpr + str_size_in_pixels.y_size / 2;
  373.             if (Debug)
  374.             printf("CENTRE and up, str=%s \n", str);
  375.             break;
  376.         }
  377.         case gpr_$right:    /* horizontal */
  378.         {
  379.             xgpr = xgpr - str_size_in_pixels.x_size / 2;
  380.             ygpr = ygpr + str_size_in_pixels.y_size / 2;
  381.             if (Debug)
  382.             printf("CENTRE and right, str=%s \n", str);
  383.             break;
  384.         }
  385.         }
  386.         break;
  387.     }
  388.     case RIGHT:
  389.     {
  390.         switch (gpr_path) {
  391.         case gpr_$up:    /* vertical */
  392.         {
  393.             ygpr = ygpr + str_size_in_pixels.y_size;
  394.             if (Debug)
  395.             printf("RIGHT and up, str=%s \n", str);
  396.             break;
  397.         }
  398.         case gpr_$right:    /* horizontal */
  399.         {
  400.             xgpr = xgpr - str_size_in_pixels.x_size;
  401.             ygpr = ygpr + str_size_in_pixels.y_size / 2;
  402.             if (Debug)
  403.             printf("RIGHT and right, str=%s \n", str);
  404.             break;
  405.         }
  406.         }
  407.         break;
  408.     }
  409.     }
  410.  
  411.     gpr_$move(xgpr, ygpr, &status);
  412.     check("in gpr_$move");
  413.     gpr_$text(str, str_len, &status);
  414.     check("in gpr_$text");
  415. }
  416.  
  417. TERM_PUBLIC int GPR_text_angle(ang)
  418. int ang;
  419. {
  420.     if (gpr_ang != ang) {
  421.     gpr_ang = ang;
  422.     gpr_path = (gpr_ang == 1 ? gpr_$up : gpr_$right);
  423.     }
  424.     return (TRUE);
  425. }
  426.  
  427. TERM_PUBLIC int GPR_justify_text(mode)
  428. enum JUSTIFY mode;
  429. {
  430.     gpr_justify = mode;
  431.     return (TRUE);
  432. }
  433.  
  434. TERM_PUBLIC void GPR_reset()
  435. {
  436.     gpr_$terminate(false, &status);
  437.     check("in gpr_$terminate");
  438. }
  439.  
  440. #endif /* TERM_BODY */
  441.  
  442. #ifdef TERM_TABLE
  443.  
  444. TERM_TABLE_START(gpr_driver)
  445.     "gpr", "Apollo Graphics Primitive Resource, fixed-size window",
  446.     GPR_XMAX, GPR_YMAX, GPR_VCHAR, GPR_HCHAR,
  447.     GPR_VTIC, GPR_HTIC, options_null, GPR_init, GPR_reset,
  448.     GPR_text, null_scale, GPR_graphics, GPR_move, GPR_vector,
  449.     GPR_linetype, GPR_put_text, GPR_text_angle,
  450.     GPR_justify_text, line_and_point, do_arrow, set_font_null
  451. TERM_TABLE_END(gpr_driver)
  452.  
  453. #undef LAST_TERM
  454. #define LAST_TERM gpr_driver
  455.  
  456. #endif /* TERM_TABLE */
  457. #endif /* TERM_PROTO_ONLY */
  458.  
  459. #ifdef TERM_HELP
  460. START_HELP(gpr)
  461. "1 gpr",
  462. "?commands set terminal gpr",
  463. "?set terminal gpr",
  464. "?set term gpr",
  465. "?terminal gpr",
  466. "?term gpr",
  467. "?gpr",
  468. " The `gpr` terminal driver supports the Apollo Graphics Primitive Resource",
  469. " for a fixed-size window.  It has no options.",
  470. "",
  471. " If a variable window size is desired, use the `apollo` terminal instead."
  472. END_HELP(gpr)
  473. #endif /* TERM_HELP */
  474.